#![allow(dead_code)]
use chrono::{DateTime, FixedOffset, NaiveDateTime, TimeZone, Utc};
use serde_json::{Map, Value};
/// 将 JSON 值转换为字符串
pub fn to_json_string(json: Option<serde_json::Value>) -> Option<String> {
    json.and_then(|v| serde_json::to_string(&v).ok())
}

/// 获取当前时间戳
pub fn get_time() -> i64 {
    // 直接获取 UTC 时间戳（秒级）
    let utc_timestamp = Utc::now().timestamp();
    // 转换为 UTC+8 的时间戳（注意：时间戳是绝对时间，与时区无关！）
    utc_timestamp
    // 不需要手动加减时区偏移，因为时间戳本身就是从 UTC 1970-01-01 开始的秒数
}

/// 获取当前日期时间
pub fn get_date_time() -> NaiveDateTime {
    // 获取当前 UTC 时间戳（秒级）
    let timestamp = Utc::now().timestamp();

    // 使用推荐的 API 构建 DateTime<FixedOffset>
    let china_timezone = FixedOffset::east_opt(8 * 3600).unwrap();
    let china_time: DateTime<FixedOffset> = china_timezone
        .timestamp_opt(timestamp, 0)  // 精确到秒（纳秒为 0）
        .unwrap();

    // 转换为 NaiveDateTime（丢弃时区信息，但保留 UTC+8 的日期时间数值）
    china_time.naive_local()
}

/// 合并两个 JSON 对象
pub fn merge_json_objects(ori_obj: &Value, new_obj: &Value) -> Value {
    match (ori_obj, new_obj) {
        // 两者都是对象时进行深度合并
        (Value::Object(orig_map), Value::Object(new_map)) => {
            let mut result = Map::new();

            // 首先添加原始对象的所有字段（作为基础）
            for (key, value) in orig_map {
                result.insert(key.clone(), value.clone());
            }

            // 然后处理新对象的字段
            for (key, new_value) in new_map {
                // 检查新值是否"为空"（根据业务需求定义）
                if is_value_empty(new_value) {
                    // 如果新值为空，且原始对象有该字段，则保留原始值
                    if let Some(orig_value) = orig_map.get(key) {
                        result.insert(key.clone(), orig_value.clone());
                    } else {
                        // 原始对象没有该字段，删除它（或保留为空）
                        result.remove(key);
                    }
                } else {
                    // 新值不为空 - 需要判断是否递归合并对象
                    if let Some(Value::Object(orig_submap)) = orig_map.get(key) {
                        if let Value::Object(new_submap) = new_value {
                            // 递归合并子对象
                            let merged = merge_json_objects(
                                &Value::Object(orig_submap.clone()),
                                &Value::Object(new_submap.clone())
                            );
                            result.insert(key.clone(), merged);
                            continue;
                        }
                    }

                    // 非对象或不需要递归合并，直接使用新值
                    result.insert(key.clone(), new_value.clone());
                }
            }

            Value::Object(result)
        }
        // 当新对象不是对象时，直接返回新对象
        _ => new_obj.clone(),
    }
}

/// 合并两个 JSON 字符串
pub fn merge_json_str(ori_cfg: &str, new_cfg: &str) -> Option<String> {
    // 解析两个配置
    let new_json = to_json_obj(new_cfg);
    let ori_json = to_json_obj(ori_cfg);

    // 如果任一配置为空，返回另一个
    if new_json.is_none() {
        return Some(String::from(ori_cfg));
    }

    if ori_json.is_none() {
        return Some(String::from(new_cfg));
    }

    // 合并两个 JSON 对象
    let merged=merge_json_objects(&ori_json?, &new_json?);

    // 序列化为字符串
    to_json_str(&merged)
}

/// 定义什么样的JSON值被视为"空"
pub fn is_value_empty(value: &Value) -> bool {
    match value {
        // null 明确表示空
        Value::Null => true,

        // 空字符串视为空
        Value::String(s) => s.is_empty(),

        // 空数组视为空
        Value::Array(arr) => arr.is_empty(),

        // 空对象视为空
        Value::Object(obj) => obj.is_empty(),

        // 布尔值、数字等永远不为空
        _ => false,
    }
}

/// 解析 JSON 字符串，失败时记录错误并返回 None
pub fn to_json_obj(json_str: &str) -> Option<Value> {
    if json_str.is_empty() {
        return None;
    }

    match serde_json::from_str(json_str) {
        Ok(json) => Some(json),
        Err(e) => {
            log::error!("Failed to parse JSON: {}", e);
            None
        }
    }
}

/// 将 JSON 值序列化为字符串，失败时记录错误并返回 None
pub fn to_json_str(json: &Value) -> Option<String> {
    match serde_json::to_string(json) {
        Ok(s) => Some(s),
        Err(e) => {
            log::error!("Failed to serialize JSON: {}", e);
            None
        }
    }
}

// /// 将嵌套的 JSON 配置映射展开为键值对
// pub fn flatten_config_map(config_map: &HashMap<String, YamlValue>) -> HashMap<String, String> {
//     let mut flattened = HashMap::new();
//     flatten_recursive(config_map, &mut flattened, "");
//     flattened
// }
//
// /// 递归处理嵌套的 YAML 配置映射
// fn flatten_recursive(
//     map: &HashMap<String, YamlValue>,
//     flattened: &mut HashMap<String, String>,
//     parent_key: &str,
// ) {
//     for (key, value) in map {
//         let full_key = if parent_key.is_empty() {
//             key.clone()
//         } else {
//             format!("{}.{}", parent_key, key)
//         };
//
//         match value {
//             YamlValue::String(s) => {
//                 flattened.insert(full_key, s.clone());
//             }
//             YamlValue::Number(n) => {
//                 flattened.insert(full_key, n.to_string());
//             }
//             YamlValue::Bool(b) => {
//                 flattened.insert(full_key, b.to_string());
//             }
//             YamlValue::Mapping(m) => {
//                 // 递归处理嵌套映射
//                 let mut nested_map = HashMap::new();
//                 for (k, v) in m {
//                     if let Some(k_str) = k.as_str() {
//                         nested_map.insert(k_str.to_string(), v.clone());
//                     }
//                 }
//                 flatten_recursive(&nested_map, flattened, &full_key);
//             }
//             YamlValue::Sequence(s) => {
//                 // 将数组转换为 JSON 字符串
//                 let json_array = serde_json::to_string(s)
//                     .unwrap_or_else(|_| "[]".to_string());
//                 flattened.insert(full_key, json_array);
//             }
//             YamlValue::Null => {
//                 flattened.insert(full_key, "".to_string());
//             }
//             _ => {}
//         }
//     }
// }